home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 22 / CU Amiga Magazine's Super CD-ROM 22 (1998)(EMAP Images)(GB)[!][issue 1998-05].iso / PowerPC / Programming / PPCSmallEiffel / bin_c / compile_to_jvm29.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  45.4 KB  |  1,775 lines
  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.82)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "compile_to_jvm.h"
  9. void r999error_comparison(T999* C,T0* a1){
  10. r683add_position((((T454*)((T454*)((((T999*)C))->_feature_name/*28*/))))->_start_position/*8*/);
  11. /*[IRF3.6append*/{T0* b1=((T0*)ms7_841);
  12. r7append(((T7*)(oBC683explanation)),b1);
  13. }/*]*/
  14. /*[IRF3.6append*/{T0* b1=a1;
  15. r7append(((T7*)(oBC683explanation)),b1);
  16. }/*]*/
  17. /*[IRF3.6append*/{T0* b1=((T0*)ms8_841);
  18. r7append(((T7*)(oBC683explanation)),b1);
  19. }/*]*/
  20. r683add_type((((T999*)C))->_current_type/*8*/,((T0*)ms67_470));
  21. r683print_as_error(((T683*)(oBC364eh)));
  22. }
  23. /*No:CALL_INFIX_EQ.arguments*/
  24. T0* r999add_comment(T999* C,T0* a1){
  25. T0* R=NULL;
  26. /*IF*/if (((a1)==((void*)(NULL)))||((/*(IRF4.6count*/r52count(((T52*)((((T393*)((T393*)a1)))->_list/*4*/)))/*)*/)==(0))) {
  27. R=(T0*)C;
  28. }
  29. else {
  30. {T529*n=malloc(sizeof(*n));
  31. *n=M529;
  32. r529make(n,(T0*)C,a1);
  33. R=(T0*)n;
  34. }
  35. }
  36. /*FI*/return R;
  37. }
  38. int r999to_integer(T999* C){
  39. int R=0;
  40. r999error(/*(IRF4.6start_position*/(((T454*)((T454*)((((T999*)C))->_feature_name/*28*/))))->_start_position/*8*//*)*/,((T0*)ms69_470));
  41. return R;
  42. }
  43. int r999is_a(T999* C,T0* a1){
  44. int R=0;
  45. R=X291is_a(X291run_type((((T999*)C))->_result_type/*20*/),X291run_type(X662result_type(a1)));
  46. /*IF*/if (!(R)) {
  47. r683add_position(/*(IRF4.6start_position*/(((T454*)((T454*)((((T999*)C))->_feature_name/*28*/))))->_start_position/*8*//*)*/);
  48. r999error(X662start_position(a1),((T0*)ms4_662));
  49. }
  50. /*FI*/return R;
  51. }
  52. /*No:CALL_INFIX_EQ.is_current*/
  53. /*No:CALL_INFIX_EQ.jvm_branch_if_false*/
  54. void r999jvm_standard_is_equal_aux(T0* a1,T0* a2){
  55. int _i=0;
  56. int _space=0;
  57. int _idx=0;
  58. int _point2=0;
  59. int _point1=0;
  60. T0* _rf2=NULL;
  61. T0* _ca=NULL;
  62. _ca=oBC364code_attribute;
  63. /*IF*/if ((a2)==((void*)(NULL))) {
  64. /*IF*/if (X291is_expanded((((T355*)((T355*)a1)))->_current_type/*0*/)) {
  65. /*[IRF3.4opcode_pop*/r256opcode(((T256*)_ca),87,-(1));
  66. /*]*/
  67. /*[IRF3.4opcode_pop*/r256opcode(((T256*)_ca),87,-(1));
  68. /*]*/
  69. /*[IRF3.4opcode_iconst_1*/r256opcode(((T256*)_ca),4,1);
  70. /*]*/
  71. }
  72. else {
  73. /*[IRF3.4opcode_swap*/r256opcode(((T256*)_ca),95,0);
  74. /*]*/
  75. /*[IRF3.4opcode_pop*/r256opcode(((T256*)_ca),87,-(1));
  76. /*]*/
  77. _idx=r355fully_qualified_constant_pool_index(((T355*)a1));
  78. r256opcode_instanceof(((T256*)_ca),_idx);
  79. }
  80. /*FI*/}
  81. else {
  82. /*[IRF3.3clear*/((((T226*)(((T226*)(oBC256branches)))))->_upper)=(-(1));
  83. /*]*/
  84. /*[IRF3.4opcode_dup*/r256opcode(((T256*)_ca),89,1);
  85. /*]*/
  86. _idx=r355fully_qualified_constant_pool_index(((T355*)a1));
  87. r256opcode_instanceof(((T256*)_ca),_idx);
  88. r226add_last(((T226*)(oBC256branches)),r256opcode_ifeq(((T256*)_ca)));
  89. _i=(((T280*)((T280*)a2)))->_upper/*12*/;
  90. while (!((_i)==(0))) {
  91. _rf2=r280item(((T280*)a2),_i);
  92. _idx=r95idx_fieldref(((T95*)(oBC364constant_pool)),_rf2);
  93. _space=(X291jvm_stack_space((((T820*)((T820*)_rf2)))->_result_type/*24*/))-(1);
  94. /*IF*/if ((_i)>(1)) {
  95. /*[IRF3.4opcode_dup2*/r256opcode(((T256*)_ca),92,2);
  96. /*]*/
  97. }
  98. /*FI*/r256opcode_getfield(((T256*)_ca),_idx,_space);
  99. /*IF*/if ((_space)==(0)) {
  100. /*[IRF3.4opcode_swap*/r256opcode(((T256*)_ca),95,0);
  101. /*]*/
  102. }
  103. else {
  104. /*[IRF3.4opcode_dup2_x1*/r256opcode(((T256*)_ca),93,2);
  105. /*]*/
  106. /*[IRF3.4opcode_pop2*/r256opcode(((T256*)_ca),88,-(2));
  107. /*]*/
  108. }
  109. /*FI*/r256opcode_getfield(((T256*)_ca),_idx,_space);
  110. /*IF*/if ((_i)>(1)) {
  111. r226add_last(((T226*)(oBC256branches)),X291jvm_if_x_ne((((T820*)((T820*)_rf2)))->_result_type/*24*/));
  112. }
  113. else {
  114. _point1=X291jvm_if_x_ne((((T820*)((T820*)_rf2)))->_result_type/*24*/);
  115. }
  116. /*FI*/_i=(_i)-(1);
  117. }
  118. /*[IRF3.4opcode_iconst_1*/r256opcode(((T256*)_ca),4,1);
  119. /*]*/
  120. _point2=r256opcode_goto(((T256*)_ca));
  121. /*[IRF3.2resolve_branches*/r256resolve_with(oBC256branches);
  122. /*]*/
  123. /*[IRF3.4opcode_pop*/r256opcode(((T256*)_ca),87,-(1));
  124. /*]*/
  125. /*[IRF3.4opcode_pop*/r256opcode(((T256*)_ca),87,-(1));
  126. /*]*/
  127. r256resolve_u2_branch(_point1);
  128. /*[IRF3.4opcode_iconst_0*/r256opcode(((T256*)_ca),3,1);
  129. /*]*/
  130. r256resolve_u2_branch(_point2);
  131. }
  132. /*FI*/}
  133. T0* r999type_boolean(void){
  134. if (fBC364type_boolean==0){
  135. T0* R=NULL;
  136. fBC364type_boolean=1;
  137. {T707*n=malloc(sizeof(*n));
  138. *n=M707;
  139. r707make(n,NULL);
  140. R=(T0*)n;
  141. }
  142. oBC364type_boolean=R;}
  143. return oBC364type_boolean;}
  144. /*No:CALL_INFIX_EQ.static_value*/
  145. void r999make(T999* C,T0* a1,T0* a2,T0* a3){
  146. T0* _eal=NULL;
  147. /*IF*/if (((a1)==((void*)(NULL)))||((a3)==((void*)(NULL)))) {
  148. r683add_position(a2);
  149. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms1_618);
  150. r683fatal_error(((T683*)(oBC364eh)),b1);
  151. }/*]*/
  152. }
  153. /*FI*/{T454*n=malloc(sizeof(*n));
  154. *n=M454;
  155. r454make(n,r999operator(),a2);
  156. C->_feature_name=(T0*)n;
  157. }
  158. {T431*n=malloc(sizeof(*n));
  159. *n=M431;
  160. /*[IRF3.3make*/((((T431*)(n)))->_list)=(se_ma96(1,a3));
  161. /*]*/
  162. _eal=(T0*)n;
  163. }
  164. r999make_call_1(C,a1,(((T999*)C))->_feature_name/*28*/,_eal);
  165. }
  166. /*No:CALL_INFIX_EQ.nb_errors*/
  167. void r999to_runnable_equal_not_equal(T999* C,T0* a1){
  168. T0* _at=NULL;
  169. T0* _tt=NULL;
  170. T0* _a=NULL;
  171. T0* _t=NULL;
  172. C->_current_type=a1;
  173. _t=X662to_runnable((((T999*)C))->_target/*12*/,a1);
  174. /*IF*/if ((_t)==((void*)(NULL))) {
  175. r999error(X662start_position((((T999*)C))->_target/*12*/),((T0*)ms1_841));
  176. }
  177. else {
  178. C->_target=_t;
  179. }
  180. /*FI*/_a=r431to_runnable(((T431*)((((T999*)C))->_arguments/*24*/)),a1);
  181. /*IF*/if ((_a)!=((void*)(NULL))) {
  182. C->_arguments=_a;
  183. }
  184. /*FI*//*IF*/if ((/*(IRF4.9nb_errors*/(((T683*)((T683*)(oBC364eh))))->_nb_errors/*0*//*)*/)==(0)) {
  185. _tt=X291run_type(X662result_type((((T999*)C))->_target/*12*/));
  186. _at=X291run_type(X662result_type(/*(IRF4.6arg1*/r431first(((T431*)((((T999*)C))->_arguments/*24*/)))/*)*/));
  187. /*IF*/if (X291is_none(_tt)) {
  188. /*IF*/if (X291is_expanded(_at)) {
  189. X291used_as_reference(_at);
  190. }
  191. /*FI*/}
  192.  else if (X291is_none(_at)) {
  193. /*IF*/if (X291is_expanded(_tt)) {
  194. X291used_as_reference(_tt);
  195. }
  196. /*FI*/}
  197.  else if (X291is_reference(_tt)) {
  198. /*IF*/if (X291is_reference(_at)) {
  199. /*IF*/if (X291is_a(_tt,_at)) {
  200. }
  201. else {
  202. /*[IRF3.2cancel*//*[IRF3.3clear*/((((T7*)(((T7*)(oBC683explanation)))))->_count)=(0);
  203. /*]*/
  204. r38clear(((T38*)(oBC683positions)));
  205. /*]*/
  206. /*IF*/if (X291is_a(_at,_tt)) {
  207. }
  208. else {
  209. r999error_comparison(C,((T0*)ms2_841));
  210. }
  211. /*FI*/}
  212. /*FI*/}
  213.  else if (!(X291is_a(_at,_tt))) {
  214. r999error_comparison(C,((T0*)ms3_841));
  215. }
  216. else {
  217. X291used_as_reference(_at);
  218. }
  219. /*FI*/}
  220. else {
  221. /*IF*/if (X291is_expanded(_at)) {
  222. /*IF*/if (X291is_basic_eiffel_expanded(_at)) {
  223. /*IF*/if (X291is_a(_tt,_at)) {
  224. }
  225. else {
  226. /*[IRF3.2cancel*//*[IRF3.3clear*/((((T7*)(((T7*)(oBC683explanation)))))->_count)=(0);
  227. /*]*/
  228. r38clear(((T38*)(oBC683positions)));
  229. /*]*/
  230. /*IF*/if (X291is_a(_at,_tt)) {
  231. }
  232. else {
  233. r999error_comparison(C,((T0*)ms4_841));
  234. }
  235. /*FI*/}
  236. /*FI*/}
  237.  else if (X291is_bit(_tt)) {
  238. r999bit_limitation(C,_tt,_at);
  239. }
  240.  else if (!(X291is_a(_at,_tt))) {
  241. r999error_comparison(C,((T0*)ms5_841));
  242. }
  243. /*FI*/}
  244.  else if (!(X291is_a(_tt,_at))) {
  245. r999error_comparison(C,((T0*)ms6_841));
  246. }
  247. else {
  248. X291used_as_reference(_tt);
  249. }
  250. /*FI*/}
  251. /*FI*/}
  252. /*FI*/}
  253. /*No:CALL_INFIX_EQ.feature_name*/
  254. /*No:CALL_INFIX_EQ.compile_to_jvm_assignment*/
  255. /*No:CALL_INFIX_EQ.fz_iinaiv*/
  256. /*No:CALL_INFIX_EQ.arg_count*/
  257. /*No:CALL_INFIX_EQ.jvm_branch_if_true*/
  258. /*No:CALL_INFIX_EQ.run_feature*/
  259. /*No:CALL_INFIX_EQ.start_position*/
  260. void r999compile_to_jvm_old(T999* C){
  261. X662compile_to_jvm_old((((T999*)C))->_target/*12*/);
  262. /*IF*/{/*AT*/r431compile_to_jvm_old(((T431*)((((T999*)C))->_arguments/*24*/)));
  263. }
  264. /*FI*/}
  265. /*No:CALL_INFIX_EQ.target*/
  266. T0* r999to_runnable(T999* C,T0* a1){
  267. T0* R=NULL;
  268. /*IF*/if (((((T999*)C))->_current_type/*8*/)==((void*)(NULL))) {
  269. r999to_runnable_equal_not_equal(C,a1);
  270. C->_result_type=r999type_boolean();
  271. /*IF*/if ((/*(IRF4.9nb_errors*/(((T683*)((T683*)(oBC364eh))))->_nb_errors/*0*//*)*/)==(0)) {
  272. R=(T0*)C;
  273. }
  274. /*FI*/}
  275. else {
  276. {T999*n=malloc(sizeof(*n));
  277. *n=M999;
  278. r999make(n,(((T999*)C))->_target/*12*/,(((T454*)((T454*)((((T999*)C))->_feature_name/*28*/))))->_start_position/*8*/,/*(IRF4.6arg1*/r431first(((T431*)((((T999*)C))->_arguments/*24*/)))/*)*/);
  279. R=(T0*)n;
  280. }
  281. R=r999to_runnable(((T999*)R),a1);
  282. }
  283. /*FI*/return R;
  284. }
  285. /*No:CALL_INFIX_EQ.result_type*/
  286. /*No:CALL_INFIX_EQ.is_result*/
  287. T0* r999operator(void){
  288. T0* R=NULL;
  289. R=((T0*)ms31_473);
  290. return R;
  291. }
  292. int r999is_static(T999* C){
  293. int R=0;
  294. /*IF*/if (X662is_void((((T999*)C))->_target/*12*/)) {
  295. R=r999is_static_eq_void(C,/*(IRF4.6arg1*/r431first(((T431*)((((T999*)C))->_arguments/*24*/)))/*)*/);
  296. }
  297.  else if (X662is_void(/*(IRF4.6arg1*/r431first(((T431*)((((T999*)C))->_arguments/*24*/)))/*)*/)) {
  298. R=r999is_static_eq_void(C,(((T999*)C))->_target/*12*/);
  299. }
  300.  else if ((X662is_static((((T999*)C))->_target/*12*/))&&(X662is_static(/*(IRF4.6arg1*/r431first(((T431*)((((T999*)C))->_arguments/*24*/)))/*)*/))) {
  301. R=1;
  302. /*IF*/if ((X662static_value((((T999*)C))->_target/*12*/))==(X662static_value(/*(IRF4.6arg1*/r431first(((T431*)((((T999*)C))->_arguments/*24*/)))/*)*/))) {
  303. C->_static_value_mem=1;
  304. }
  305. /*FI*/}
  306. /*FI*/return R;
  307. }
  308. void r999standard_compile_target_to_jvm(T999* C){
  309. r999compile_to_jvm(C);
  310. X291jvm_check_class_invariant((((T999*)C))->_result_type/*20*/);
  311. }
  312. int r999compile_to_jvm_into(T999* C,T0* a1){
  313. int R=0;
  314. R=r999standard_compile_to_jvm_into(C,a1);
  315. return R;
  316. }
  317. /*No:CALL_INFIX_EQ.compile_target_to_jvm*/
  318. int r999is_static_eq_void(T999* C,T0* a1){
  319. int R=0;
  320. T0* _rt=NULL;
  321. /*IF*/if (X662is_current(a1)) {
  322. R=1;
  323. }
  324.  else if (X662is_manifest_string(a1)) {
  325. R=1;
  326. }
  327.  else if (r999is_manifest_array(a1)) {
  328. R=1;
  329. }
  330. else {
  331. _rt=X291run_type(X662result_type(a1));
  332. /*IF*/if (X291is_expanded(_rt)) {
  333. /*IF*/if (X662can_be_dropped(a1)) {
  334. R=1;
  335. }
  336. /*FI*/}
  337.  else if (X662is_static(a1)) {
  338. /*IF*/if ((X662static_value(a1))==(0)) {
  339. R=1;
  340. C->_static_value_mem=1;
  341. }
  342. /*FI*/}
  343. /*FI*/}
  344. /*FI*/return R;
  345. }
  346. /*No:CALL_INFIX_EQ.can_be_dropped*/
  347. void r999bit_limitation(T999* C,T0* a1,T0* a2){
  348. T0* _b2=NULL;
  349. T0* _b1=NULL;
  350. _b1=a1;
  351. if(NULL!=(_b1))switch(((T0*)_b1)->id) {
  352. case 549: case 558: 
  353. break;
  354. default:
  355. _b1=NULL;
  356. };_b2=a2;
  357. if(NULL!=(_b2))switch(((T0*)_b2)->id) {
  358. case 549: case 558: 
  359. break;
  360. default:
  361. _b2=NULL;
  362. };/*IF*/if ((X609nb(_b1))!=(X609nb(_b2))) {
  363. r683add_position((((T454*)((T454*)((((T999*)C))->_feature_name/*28*/))))->_start_position/*8*/);
  364. /*[IRF3.6append*/{T0* b1=((T0*)ms9_841);
  365. r7append(((T7*)(oBC683explanation)),b1);
  366. }/*]*/
  367. r683add_type(_b1,((T0*)ms10_841));
  368. r683add_type(_b2,((T0*)ms11_841));
  369. r683print_as_fatal_error(((T683*)(oBC364eh)));
  370. }
  371. /*FI*/}
  372. /*No:CALL_INFIX_EQ.current_type*/
  373. /*No:CALL_INFIX_EQ.jvm_assign*/
  374. /*No:CALL_INFIX_EQ.static_value_mem*/
  375. void r999make_call_1(T999* C,T0* a1,T0* a2,T0* a3){
  376. C->_target=a1;
  377. C->_feature_name=a2;
  378. C->_arguments=a3;
  379. }
  380. /*No:CALL_INFIX_EQ.is_manifest_string*/
  381. /*No:CALL_INFIX_EQ.us_eq*/
  382. /*No:CALL_INFIX_EQ.is_void*/
  383. int r999is_manifest_array(T0* a1){
  384. int R=0;
  385. T0* _ma=NULL;
  386. _ma=a1;
  387. if(NULL!=(_ma))switch(((T0*)_ma)->id) {
  388. case 436: 
  389. break;
  390. default:
  391. _ma=NULL;
  392. };R=(_ma)!=((void*)(NULL));
  393. return R;
  394. }
  395. int r999jvm_standard_branch_if_false(T999* C){
  396. int R=0;
  397. r999compile_to_jvm(C);
  398. R=r256opcode_ifeq(((T256*)(oBC364code_attribute)));
  399. return R;
  400. }
  401. /*No:CALL_INFIX_EQ.fz_dot*/
  402. void r999compile_to_jvm(T999* C){
  403. T0* _rc=NULL;
  404. T0* _rt=NULL;
  405. int _point2=0;
  406. int _point1=0;
  407. int _space=0;
  408. /*IF*/if (X662is_void((((T999*)C))->_target/*12*/)) {
  409. r999jvm_void_cmp(/*(IRF4.6arg1*/r431first(((T431*)((((T999*)C))->_arguments/*24*/)))/*)*/);
  410. }
  411.  else if (X662is_void(/*(IRF4.6arg1*/r431first(((T431*)((((T999*)C))->_arguments/*24*/)))/*)*/)) {
  412. r999jvm_void_cmp((((T999*)C))->_target/*12*/);
  413. }
  414. else {
  415. _rt=X291smallest_ancestor(X662result_type((((T999*)C))->_target/*12*/),X662result_type(/*(IRF4.6arg1*/r431first(((T431*)((((T999*)C))->_arguments/*24*/)))/*)*/));
  416. _space=X662compile_to_jvm_into((((T999*)C))->_target/*12*/,_rt);
  417. _space=X662compile_to_jvm_into(/*(IRF4.6arg1*/r431first(((T431*)((((T999*)C))->_arguments/*24*/)))/*)*/,_rt);
  418. /*IF*/if (X291is_user_expanded(_rt)) {
  419. _rc=X291run_class(_rt);
  420. r999jvm_standard_is_equal_aux(_rc,r355writable_attributes(((T355*)_rc)));
  421. }
  422. else {
  423. _point1=X291jvm_if_x_eq(_rt);
  424. /*[IRF3.4opcode_iconst_0*/r256opcode(((T256*)(oBC364code_attribute)),3,1);
  425. /*]*/
  426. _point2=r256opcode_goto(((T256*)(oBC364code_attribute)));
  427. r256resolve_u2_branch(_point1);
  428. /*[IRF3.4opcode_iconst_1*/r256opcode(((T256*)(oBC364code_attribute)),4,1);
  429. /*]*/
  430. r256resolve_u2_branch(_point2);
  431. }
  432. /*FI*/}
  433. /*FI*/}
  434. void r999jvm_void_cmp(T0* a1){
  435. int _space=0;
  436. int _point2=0;
  437. int _point1=0;
  438. T0* _rt=NULL;
  439. _rt=X291run_type(X662result_type(a1));
  440. /*IF*/if (X291is_expanded(_rt)) {
  441. X662compile_to_jvm(a1);
  442. _space=X291jvm_stack_space(_rt);
  443. while (!((_space)==(0))) {
  444. /*[IRF3.4opcode_pop*/r256opcode(((T256*)(oBC364code_attribute)),87,-(1));
  445. /*]*/
  446. _space=(_space)-(1);
  447. }
  448. /*[IRF3.4opcode_iconst_0*/r256opcode(((T256*)(oBC364code_attribute)),3,1);
  449. /*]*/
  450. }
  451. else {
  452. X662compile_to_jvm(a1);
  453. _point1=r256opcode_ifnull(((T256*)(oBC364code_attribute)));
  454. /*[IRF3.4opcode_iconst_0*/r256opcode(((T256*)(oBC364code_attribute)),3,1);
  455. /*]*/
  456. _point2=r256opcode_goto(((T256*)(oBC364code_attribute)));
  457. r256resolve_u2_branch(_point1);
  458. /*[IRF3.4opcode_iconst_1*/r256opcode(((T256*)(oBC364code_attribute)),4,1);
  459. /*]*/
  460. r256resolve_u2_branch(_point2);
  461. }
  462. /*FI*/}
  463. /*No:CALL_INFIX_EQ.is_pre_computable*/
  464. int r999jvm_standard_branch_if_true(T999* C){
  465. int R=0;
  466. r999compile_to_jvm(C);
  467. R=r256opcode_ifne(((T256*)(oBC364code_attribute)));
  468. return R;
  469. }
  470. int r999use_current(T999* C){
  471. int R=0;
  472. R=(X662use_current((((T999*)C))->_target/*12*/))||(X662use_current(/*(IRF4.6arg1*/r431first(((T431*)((((T999*)C))->_arguments/*24*/)))/*)*/));
  473. return R;
  474. }
  475. void r999error(T0* a1,T0* a2){
  476. r683add_position(a1);
  477. r683error(((T683*)(oBC364eh)),a2);
  478. }
  479. /*No:CALL_INFIX_EQ.isa_dca_inline_argument*/
  480. /*No:CALL_INFIX_EQ.fatal_error*/
  481. /*No:CALL_INFIX_EQ.arg1*/
  482. int r999standard_compile_to_jvm_into(T999* C,T0* a1){
  483. int R=0;
  484. r999compile_to_jvm(C);
  485. R=X291jvm_convert_to(X291run_type((((T999*)C))->_result_type/*20*/),a1);
  486. return R;
  487. }
  488. void r999afd_check(T999* C){
  489. X662afd_check((((T999*)C))->_target/*12*/);
  490. X662afd_check(/*(IRF4.6arg1*/r431first(((T431*)((((T999*)C))->_arguments/*24*/)))/*)*/);
  491. }
  492. /*No:CODE_ATTRIBUTE.opcode_fconst_0*/
  493. /*No:CODE_ATTRIBUTE.opcode_dconst_0*/
  494. /*No:CODE_ATTRIBUTE.opcode_iconst_0*/
  495. int r256opcode_goto(T256* C){
  496. int R=0;
  497. r256opcode(C,167,0);
  498. R=r256skip_2_bytes();
  499. return R;
  500. }
  501. int r256skip_2_bytes(void){
  502. int R=0;
  503. R=/*(IRF4.9program_counter*//*(IRF4.6count*/((((T226*)((T226*)(oBC256code))))->_upper/*8*/)+(1)/*)*//*)*/;
  504. r226add_last(((T226*)(oBC256code)),0);
  505. r226add_last(((T226*)(oBC256code)),0);
  506. return R;
  507. }
  508. /*No:CODE_ATTRIBUTE.opcode_dup_x2*/
  509. void r256opcode_invokespecial(T256* C,int a1,int a2){
  510. r256opcode(C,183,a2);
  511. r256add_u2(a1);
  512. }
  513. int r256opcode_ifgt(T256* C){
  514. int R=0;
  515. r256opcode(C,157,-(1));
  516. R=r256skip_2_bytes();
  517. return R;
  518. }
  519. /*No:CODE_ATTRIBUTE.check_flag_idx*/
  520. /*No:CODE_ATTRIBUTE.opcode_fdiv*/
  521. /*No:CODE_ATTRIBUTE.opcode_astore_1*/
  522. void r256opcode_invokestatic(T256* C,int a1,int a2){
  523. r256opcode(C,184,a2);
  524. r256add_u2(a1);
  525. }
  526. /*No:CODE_ATTRIBUTE.opcode_aconst_null*/
  527. /*No:CODE_ATTRIBUTE.max_locals*/
  528. /*No:CODE_ATTRIBUTE.opcode_dcmpg*/
  529. /*No:CODE_ATTRIBUTE.program_counter*/
  530. /*No:CODE_ATTRIBUTE.opcode_fadd*/
  531. /*No:CODE_ATTRIBUTE.opcode_irem*/
  532. /*No:CODE_ATTRIBUTE.opcode_dneg*/
  533. /*No:CODE_ATTRIBUTE.add_u1*/
  534. int r256opcode_if_icmpgt(T256* C){
  535. int R=0;
  536. r256opcode(C,163,-(2));
  537. R=r256skip_2_bytes();
  538. return R;
  539. }
  540. /*No:CODE_ATTRIBUTE.opcode_iconst_1*/
  541. /*No:CODE_ATTRIBUTE.append_u1*/
  542. int r256opcode_if_icmpne(T256* C){
  543. int R=0;
  544. r256opcode(C,160,-(2));
  545. R=r256skip_2_bytes();
  546. return R;
  547. }
  548. T0*oBC256code=NULL;
  549. void r256add_u2(int a1){
  550. /*[IRF3.6add_u1*/{int b1=(a1)/(256);
  551. r226add_last(((T226*)(oBC256code)),b1);
  552. }/*]*/
  553. /*[IRF3.6add_u1*/{int b1=(a1)%(256);
  554. r226add_last(((T226*)(oBC256code)),b1);
  555. }/*]*/
  556. }
  557. /*No:CODE_ATTRIBUTE.opcode_dsub*/
  558. /*No:CODE_ATTRIBUTE.opcode_freturn*/
  559. /*No:CODE_ATTRIBUTE.opcode_dreturn*/
  560. /*No:CODE_ATTRIBUTE.opcode_ireturn*/
  561. /*No:CODE_ATTRIBUTE.opcode_areturn*/
  562. void r256opcode_system_err(T256* C){
  563. int _idx=0;
  564. _idx=r95idx_fieldref3(((T95*)(oBC364constant_pool)),((T0*)ms168_470),((T0*)ms175_470),((T0*)ms172_470));
  565. r256opcode_getstatic(C,_idx,1);
  566. }
  567. /*No:CODE_ATTRIBUTE.opcode_dup2*/
  568. void r256append_u2(T0* a1,int a2){
  569. /*[IRF3.6append_u1*/{T0* b1=a1;
  570. int b2=(a2)/(256);
  571. r7extend(((T7*)b1),((char)(b2)));
  572. }/*]*/
  573. /*[IRF3.6append_u1*/{T0* b1=a1;
  574. int b2=(a2)%(256);
  575. r7extend(((T7*)b1),((char)(b2)));
  576. }/*]*/
  577. }
  578. /*No:CODE_ATTRIBUTE.opcode_fcmpg*/
  579. void r256push_strange_integer(T256* C,int a1){
  580. T0* _cp=NULL;
  581. int _idx=0;
  582. _cp=oBC364constant_pool;
  583. /*[IRF3.3clear*/((((T7*)(((T7*)(oBC256tmp_string)))))->_count)=(0);
  584. /*]*/
  585. r2append_in(a1,oBC256tmp_string);
  586. _idx=r95idx_string(((T95*)_cp),oBC256tmp_string);
  587. r256opcode_ldc(C,_idx);
  588. _idx=r95idx_methodref3(((T95*)_cp),((T0*)ms207_470),((T0*)ms208_470),((T0*)ms209_470));
  589. r256opcode_invokestatic(C,_idx,0);
  590. }
  591. void r256opcode_aload(T256* C,int a1){
  592. /*IF*/if ((a1)<=(3)) {
  593. r256opcode(C,(42)+(a1),1);
  594. }
  595. else {
  596. r256opcode(C,25,1);
  597. /*[IRF3.6add_u1*/{int b1=a1;
  598. r226add_last(((T226*)(oBC256code)),b1);
  599. }/*]*/
  600. }
  601. /*FI*/}
  602. /*No:CODE_ATTRIBUTE.opcode_idiv*/
  603. void r256check_opening(T256* C){
  604. T0* _cp=NULL;
  605. _cp=oBC364constant_pool;
  606. C->_check_flag_idx=r95idx_fieldref3(((T95*)_cp),r256jvm_root_class(),((T0*)ms184_470),((T0*)ms173_470));
  607. r256opcode_getstatic(C,(((T256*)C))->_check_flag_idx/*16*/,1);
  608. C->_skip_check=r256opcode_ifne(C);
  609. /*[IRF3.4opcode_iconst_1*/r256opcode(C,4,1);
  610. /*]*/
  611. r256opcode_putstatic(C,(((T256*)C))->_check_flag_idx/*16*/,-(1));
  612. }
  613. /*No:CODE_ATTRIBUTE.opcode_fneg*/
  614. int r256opcode_ifle(T256* C){
  615. int R=0;
  616. r256opcode(C,158,-(1));
  617. R=r256skip_2_bytes();
  618. return R;
  619. }
  620. /*No:CODE_ATTRIBUTE.opcode_iushr*/
  621. T0* r256jvm_root_class(void){
  622. if (fBC364jvm_root_class==0){
  623. T0* R=NULL;
  624. fBC364jvm_root_class=1;
  625. {T7*n=malloc(sizeof(*n));
  626. *n=M7;
  627. r7make(n,12);
  628. R=(T0*)n;
  629. }
  630. r7copy(((T7*)R),(((T228*)((T228*)(oBC364jvm))))->_output_name/*16*/);
  631. r7extend(((T7*)R),'\57');
  632. r7append(((T7*)R),((T0*)ms112_470));
  633. oBC364jvm_root_class=R;}
  634. return oBC364jvm_root_class;}
  635. void r256opcode_bytes_array2eiffel_string(T256* C){
  636. int _loc=0;
  637. T0* _cp=NULL;
  638. _cp=oBC364constant_pool;
  639. _loc=r256extra_local_size1(C);
  640. r256opcode_astore(C,_loc);
  641. r256opcode_new(C,r95idx_eiffel_string_class(((T95*)_cp)));
  642. /*[IRF3.4opcode_dup*/r256opcode(C,89,1);
  643. /*]*/
  644. r256opcode_aload(C,_loc);
  645. /*[IRF3.4opcode_arraylength*/r256opcode(C,190,0);
  646. /*]*/
  647. r256opcode_putfield(C,r95idx_eiffel_string_count_fieldref(((T95*)_cp)),-(2));
  648. /*[IRF3.4opcode_dup*/r256opcode(C,89,1);
  649. /*]*/
  650. r256opcode_aload(C,_loc);
  651. /*[IRF3.4opcode_arraylength*/r256opcode(C,190,0);
  652. /*]*/
  653. r256opcode_putfield(C,r95idx_eiffel_string_capacity_fieldref(((T95*)_cp)),-(2));
  654. /*[IRF3.4opcode_dup*/r256opcode(C,89,1);
  655. /*]*/
  656. r256opcode_aload(C,_loc);
  657. r256opcode_putfield(C,r95idx_eiffel_string_storage_fieldref(((T95*)_cp)),-(2));
  658. }
  659. void r256opcode_java_string2eiffel_string(T256* C){
  660. r256opcode_java_string2bytes_array(C);
  661. r256opcode_bytes_array2eiffel_string(C);
  662. }
  663. /*No:CODE_ATTRIBUTE.opcode_iconst_i*/
  664. void r256opcode_runtime_get_runtime(T256* C){
  665. int _idx=0;
  666. _idx=r95idx_methodref3(((T95*)(oBC364constant_pool)),((T0*)ms179_470),((T0*)ms181_470),((T0*)ms182_470));
  667. r256opcode_invokestatic(C,_idx,1);
  668. }
  669. /*No:CODE_ATTRIBUTE.opcode_fsub*/
  670. /*No:CODE_ATTRIBUTE.opcode_iadd*/
  671. /*No:CODE_ATTRIBUTE.opcode_astore_3*/
  672. /*No:CODE_ATTRIBUTE.opcode_ishl*/
  673. /*No:CODE_ATTRIBUTE.opcode_aaload*/
  674. void r256opcode_system_err_println(T256* C,int a1){
  675. r256opcode_system_err(C);
  676. r256opcode_println(C,a1);
  677. }
  678. void r256resolve_with(T0* a1){
  679. int _i=0;
  680. _i=(((T226*)((T226*)a1)))->_upper/*8*/;
  681. while (!((_i)<(0))) {
  682. r256resolve_u2_branch(/*(IRF4.6item*/((((T226*)((T226*)a1)))->_storage/*0*/)[_i]/*)*/);
  683. _i=(_i)-(1);
  684. }
  685. }
  686. void r256append_u4(T0* a1,int a2){
  687. r256append_u2(a1,(a2)/(65536));
  688. r256append_u2(a1,(a2)%(65536));
  689. }
  690. void r256opcode_println(T256* C,int a1){
  691. int _idx=0;
  692. r256opcode_ldc(C,a1);
  693. _idx=r95idx_methodref3(((T95*)(oBC364constant_pool)),((T0*)ms157_470),((T0*)ms177_470),((T0*)ms183_470));
  694. r256opcode_invokevirtual(C,_idx,-(2));
  695. }
  696. void r256store_in(T256* C,T0* a1){
  697. int _i=0;
  698. r256append_u2(a1,(((T95*)((T95*)(oBC364constant_pool))))->_idx_uft8_code/*4*/);
  699. r256append_u4(a1,(12)+(/*(IRF4.9program_counter*//*(IRF4.6count*/((((T226*)((T226*)(oBC256code))))->_upper/*8*/)+(1)/*)*//*)*/));
  700. r256append_u2(a1,(((T256*)C))->_max_stack/*0*/);
  701. r256append_u2(a1,(((T256*)C))->_max_locals/*8*/);
  702. r256append_u4(a1,/*(IRF4.9program_counter*//*(IRF4.6count*/((((T226*)((T226*)(oBC256code))))->_upper/*8*/)+(1)/*)*//*)*/);
  703. _i=0;
  704. while (!((_i)>((((T226*)((T226*)(oBC256code))))->_upper/*8*/))) {
  705. /*[IRF3.6append_u1*/{T0* b1=a1;
  706. int b2=/*(IRF4.6item*/((((T226*)((T226*)(oBC256code))))->_storage/*0*/)[_i]/*)*/;
  707. r7extend(((T7*)b1),((char)(b2)));
  708. }/*]*/
  709. _i=(_i)+(1);
  710. }
  711. r613store_in(a1);
  712. r256append_u2(a1,0);
  713. }
  714. void r256opcode_push_manifest_string(T256* C,T0* a1){
  715. int _ms_idx=0;
  716. _ms_idx=r95idx_string2(((T95*)(oBC364constant_pool)),a1);
  717. r256opcode_ldc(C,_ms_idx);
  718. r256opcode_java_string2eiffel_string(C);
  719. }
  720. /*No:CODE_ATTRIBUTE.opcode_baload*/
  721. int r256opcode_ifnull(T256* C){
  722. int R=0;
  723. r256opcode(C,198,-(1));
  724. R=r256skip_2_bytes();
  725. return R;
  726. }
  727. T0*oBC256exception_table=NULL;
  728. int r256opcode_if_icmpge(T256* C){
  729. int R=0;
  730. r256opcode(C,162,-(2));
  731. R=r256skip_2_bytes();
  732. return R;
  733. }
  734. void r256opcode_dload(T256* C,int a1){
  735. /*IF*/if ((a1)<=(3)) {
  736. r256opcode(C,(38)+(a1),2);
  737. }
  738. else {
  739. r256opcode(C,24,2);
  740. /*[IRF3.6add_u1*/{int b1=a1;
  741. r226add_last(((T226*)(oBC256code)),b1);
  742. }/*]*/
  743. }
  744. /*FI*/}
  745. int r256opcode_ifne(T256* C){
  746. int R=0;
  747. r256opcode(C,154,-(1));
  748. R=r256skip_2_bytes();
  749. return R;
  750. }
  751. /*No:CODE_ATTRIBUTE.opcode_ineg*/
  752. int r256opcode_iflt(T256* C){
  753. int R=0;
  754. r256opcode(C,155,-(1));
  755. R=r256skip_2_bytes();
  756. return R;
  757. }
  758. void r256opcode_iinc(T256* C,int a1,int a2){
  759. r256opcode(C,132,0);
  760. /*[IRF3.6add_u1*/{int b1=a1;
  761. r226add_last(((T226*)(oBC256code)),b1);
  762. }/*]*/
  763. /*[IRF3.6add_u1*/{int b1=a2;
  764. r226add_last(((T226*)(oBC256code)),b1);
  765. }/*]*/
  766. }
  767. void r256opcode_push_as_float(T256* C,T0* a1){
  768. {int z1=/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(1)-(1)]/*)*/;
  769.  
  770. if((48==z1)){
  771. /*IF*/if (((((T7*)((T7*)a1)))->_count/*4*/)==(1)) {
  772. r256opcode(C,11,1);
  773. }
  774. else {
  775. {int z2=/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(2)-(1)]/*)*/;
  776.  
  777. if((46==z2)){
  778. /*IF*/if (((((T7*)((T7*)a1)))->_count/*4*/)==(2)) {
  779. r256opcode(C,11,1);
  780. }
  781.  else if ((((((T7*)((T7*)a1)))->_count/*4*/)==(3))&&((/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(3)-(1)]/*)*/)==('0'))) {
  782. r256opcode(C,11,1);
  783. }
  784. else {
  785. r256opcode_string2float(C,a1);
  786. }
  787. /*FI*/}
  788.  else{r256opcode_string2float(C,a1);
  789. }}
  790. }
  791. /*FI*/}
  792.  else 
  793. if((49==z1)){
  794. /*IF*/if (((((T7*)((T7*)a1)))->_count/*4*/)==(1)) {
  795. r256opcode(C,12,1);
  796. }
  797. else {
  798. {int z2=/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(2)-(1)]/*)*/;
  799.  
  800. if((46==z2)){
  801. /*IF*/if (((((T7*)((T7*)a1)))->_count/*4*/)==(2)) {
  802. r256opcode(C,12,1);
  803. }
  804.  else if ((((((T7*)((T7*)a1)))->_count/*4*/)==(3))&&((/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(3)-(1)]/*)*/)==('0'))) {
  805. r256opcode(C,12,1);
  806. }
  807. else {
  808. r256opcode_string2float(C,a1);
  809. }
  810. /*FI*/}
  811.  else{r256opcode_string2float(C,a1);
  812. }}
  813. }
  814. /*FI*/}
  815.  else 
  816. if((50==z1)){
  817. /*IF*/if (((((T7*)((T7*)a1)))->_count/*4*/)==(1)) {
  818. r256opcode(C,13,1);
  819. }
  820. else {
  821. {int z2=/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(2)-(1)]/*)*/;
  822.  
  823. if((46==z2)){
  824. /*IF*/if (((((T7*)((T7*)a1)))->_count/*4*/)==(2)) {
  825. r256opcode(C,13,1);
  826. }
  827.  else if ((((((T7*)((T7*)a1)))->_count/*4*/)==(3))&&((/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(3)-(1)]/*)*/)==('0'))) {
  828. r256opcode(C,13,1);
  829. }
  830. else {
  831. r256opcode_string2float(C,a1);
  832. }
  833. /*FI*/}
  834.  else{r256opcode_string2float(C,a1);
  835. }}
  836. }
  837. /*FI*/}
  838.  else{r256opcode_string2float(C,a1);
  839. }}
  840. }
  841. void r256opcode_runtime_trace_instructions(T256* C,int a1){
  842. int _idx=0;
  843. r256opcode_runtime_get_runtime(C);
  844. /*IF*/if (a1) {
  845. /*[IRF3.4opcode_iconst_1*/r256opcode(C,4,1);
  846. /*]*/
  847. }
  848. else {
  849. /*[IRF3.4opcode_iconst_0*/r256opcode(C,3,1);
  850. /*]*/
  851. }
  852. /*FI*/_idx=r95idx_methodref3(((T95*)(oBC364constant_pool)),((T0*)ms179_470),((T0*)ms178_470),((T0*)ms180_470));
  853. r256opcode_invokevirtual(C,_idx,-(2));
  854. }
  855. /*No:CODE_ATTRIBUTE.opcode_athrow*/
  856. /*No:CODE_ATTRIBUTE.opcode_isub*/
  857. /*No:CODE_ATTRIBUTE.opcode_dup2_x1*/
  858. void r256opcode_sipush(T256* C,int a1){
  859. r256opcode(C,17,1);
  860. r256add_u2(a1);
  861. }
  862. void r256clear(T256* C){
  863. /*[IRF3.3clear*/((((T226*)(((T226*)(oBC256code)))))->_upper)=(-(1));
  864. /*]*/
  865. /*[IRF3.2clear*//*[IRF3.3clear*/((((T226*)(((T226*)(oBC613from_pc)))))->_upper)=(-(1));
  866. /*]*/
  867. /*[IRF3.3clear*/((((T226*)(((T226*)(oBC613to_pc)))))->_upper)=(-(1));
  868. /*]*/
  869. /*[IRF3.3clear*/((((T226*)(((T226*)(oBC613handler_pc)))))->_upper)=(-(1));
  870. /*]*/
  871. /*[IRF3.3clear*/((((T226*)(((T226*)(oBC613type_idx)))))->_upper)=(-(1));
  872. /*]*/
  873. /*]*/
  874. C->_max_stack=0;
  875. C->_current_stack_level=0;
  876. C->_max_locals=r228max_locals(((T228*)(oBC364jvm)));
  877. }
  878. /*No:CODE_ATTRIBUTE.opcode_daload*/
  879. /*No:CODE_ATTRIBUTE.opcode_dload_0*/
  880. /*No:CODE_ATTRIBUTE.opcode_pop2*/
  881. void r256opcode_instanceof(T256* C,int a1){
  882. r256opcode(C,193,0);
  883. r256add_u2(a1);
  884. }
  885. void r256opcode_system_exit(T256* C){
  886. int _idx=0;
  887. _idx=r95idx_methodref3(((T95*)(oBC364constant_pool)),((T0*)ms168_470),((T0*)ms102_470),((T0*)ms159_470));
  888. r256opcode_invokestatic(C,_idx,0);
  889. }
  890. /*No:CODE_ATTRIBUTE.opcode_aload_0*/
  891. void r256opcode_fload(T256* C,int a1){
  892. /*IF*/if ((a1)<=(3)) {
  893. r256opcode(C,(34)+(a1),1);
  894. }
  895. else {
  896. r256opcode(C,23,1);
  897. /*[IRF3.6add_u1*/{int b1=a1;
  898. r226add_last(((T226*)(oBC256code)),b1);
  899. }/*]*/
  900. }
  901. /*FI*/}
  902. void r256opcode_newarray(T256* C,int a1){
  903. r256opcode(C,188,0);
  904. /*[IRF3.6add_u1*/{int b1=a1;
  905. r226add_last(((T226*)(oBC256code)),b1);
  906. }/*]*/
  907. }
  908. /*No:CODE_ATTRIBUTE.fz_40*/
  909. /*No:CODE_ATTRIBUTE.max_stack*/
  910. void r256opcode_getfield(T256* C,int a1,int a2){
  911. r256opcode(C,180,a2);
  912. r256add_u2(a1);
  913. }
  914. void r256opcode_putfield(T256* C,int a1,int a2){
  915. r256opcode(C,181,a2);
  916. r256add_u2(a1);
  917. }
  918. /*No:CODE_ATTRIBUTE.opcode_dup*/
  919. int r256opcode_if_acmpne(T256* C){
  920. int R=0;
  921. r256opcode(C,166,-(2));
  922. R=r256skip_2_bytes();
  923. return R;
  924. }
  925. T0*oBC256branches=NULL;
  926. /*No:CODE_ATTRIBUTE.fz_41*/
  927. /*No:CODE_ATTRIBUTE.fz_32*/
  928. void r256opcode_invokevirtual(T256* C,int a1,int a2){
  929. r256opcode(C,182,a2);
  930. r256add_u2(a1);
  931. }
  932. /*No:CODE_ATTRIBUTE.fz_60*/
  933. void r256opcode_bipush(T256* C,int a1){
  934. r256opcode(C,16,1);
  935. /*[IRF3.6add_u1*/{int b1=a1;
  936. r226add_last(((T226*)(oBC256code)),b1);
  937. }/*]*/
  938. }
  939. /*No:CODE_ATTRIBUTE.fz_51*/
  940. /*No:CODE_ATTRIBUTE.opcode_ior*/
  941. void r256opcode_new(T256* C,int a1){
  942. r256opcode(C,187,1);
  943. r256add_u2(a1);
  944. }
  945. /*No:CODE_ATTRIBUTE.skip_check*/
  946. /*No:CODE_ATTRIBUTE.fz_33*/
  947. void r256opcode_astore(T256* C,int a1){
  948. /*IF*/if ((a1)<=(3)) {
  949. r256opcode(C,(75)+(a1),-(1));
  950. }
  951. else {
  952. r256opcode(C,58,-(1));
  953. /*[IRF3.6add_u1*/{int b1=a1;
  954. r226add_last(((T226*)(oBC256code)),b1);
  955. }/*]*/
  956. }
  957. /*FI*/}
  958. int r256opcode_if_icmpeq(T256* C){
  959. int R=0;
  960. r256opcode(C,159,-(2));
  961. R=r256skip_2_bytes();
  962. return R;
  963. }
  964. /*No:CODE_ATTRIBUTE.fz_61*/
  965. void r256opcode_java_string2bytes_array(T256* C){
  966. int _idx=0;
  967. _idx=r95idx_methodref3(((T95*)(oBC364constant_pool)),((T0*)ms164_470),((T0*)ms165_470),((T0*)ms166_470));
  968. r256opcode_invokevirtual(C,_idx,0);
  969. }
  970. /*No:CODE_ATTRIBUTE.fz_52*/
  971. /*No:CODE_ATTRIBUTE.opcode_dmul*/
  972. /*No:CODE_ATTRIBUTE.opcode_aload_1*/
  973. /*No:CODE_ATTRIBUTE.opcode_faload*/
  974. /*No:CODE_ATTRIBUTE.opcode_f2d*/
  975. /*No:CODE_ATTRIBUTE.fz_34*/
  976. /*No:CODE_ATTRIBUTE.fz_62*/
  977. T0*oBC256tmp_string=NULL;
  978. /*No:CODE_ATTRIBUTE.fz_25*/
  979. /*No:CODE_ATTRIBUTE.fz_53*/
  980. /*No:CODE_ATTRIBUTE.opcode_i2b*/
  981. /*No:CODE_ATTRIBUTE.fz_81*/
  982. /*No:CODE_ATTRIBUTE.opcode_d2f*/
  983. /*No:CODE_ATTRIBUTE.resolve_branches*/
  984. /*No:CODE_ATTRIBUTE.fz_54*/
  985. /*No:CODE_ATTRIBUTE.opcode_iconst_m1*/
  986. /*No:CODE_ATTRIBUTE.fz_82*/
  987. void r256opcode_iload(T256* C,int a1){
  988. /*IF*/if ((a1)<=(3)) {
  989. r256opcode(C,(26)+(a1),1);
  990. }
  991. else {
  992. r256opcode(C,21,1);
  993. /*[IRF3.6add_u1*/{int b1=a1;
  994. r226add_last(((T226*)(oBC256code)),b1);
  995. }/*]*/
  996. }
  997. /*FI*/}
  998. /*No:CODE_ATTRIBUTE.fz_36*/
  999. void r256opcode_anewarray(T256* C,int a1){
  1000. r256opcode(C,189,0);
  1001. r256add_u2(a1);
  1002. }
  1003. /*No:CODE_ATTRIBUTE.fz_27*/
  1004. /*No:CODE_ATTRIBUTE.fz_55*/
  1005. /*No:CODE_ATTRIBUTE.opcode_fastore*/
  1006. /*No:CODE_ATTRIBUTE.opcode_iastore*/
  1007. /*No:CODE_ATTRIBUTE.opcode_dastore*/
  1008. /*No:CODE_ATTRIBUTE.opcode_bastore*/
  1009. /*No:CODE_ATTRIBUTE.opcode_aastore*/
  1010. /*No:CODE_ATTRIBUTE.fz_83*/
  1011. int r256opcode_if_icmplt(T256* C){
  1012. int R=0;
  1013. r256opcode(C,161,-(2));
  1014. R=r256skip_2_bytes();
  1015. return R;
  1016. }
  1017. /*No:CODE_ATTRIBUTE.fz_37*/
  1018. /*No:CODE_ATTRIBUTE.opcode_aload_2*/
  1019. int r256opcode_ifeq(T256* C){
  1020. int R=0;
  1021. r256opcode(C,153,-(1));
  1022. R=r256skip_2_bytes();
  1023. return R;
  1024. }
  1025. /*No:CODE_ATTRIBUTE.opcode_fmul*/
  1026. /*No:CODE_ATTRIBUTE.fz_56*/
  1027. void r256opcode_push_as_double(T256* C,T0* a1){
  1028. {int z1=/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(1)-(1)]/*)*/;
  1029.  
  1030. if((48==z1)){
  1031. /*IF*/if (((((T7*)((T7*)a1)))->_count/*4*/)==(1)) {
  1032. r256opcode(C,14,2);
  1033. }
  1034. else {
  1035. {int z2=/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(2)-(1)]/*)*/;
  1036.  
  1037. if((46==z2)){
  1038. /*IF*/if (((((T7*)((T7*)a1)))->_count/*4*/)==(2)) {
  1039. r256opcode(C,14,2);
  1040. }
  1041.  else if ((((((T7*)((T7*)a1)))->_count/*4*/)==(3))&&((/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(3)-(1)]/*)*/)==('0'))) {
  1042. r256opcode(C,14,2);
  1043. }
  1044. else {
  1045. r256opcode_string2double(C,a1);
  1046. }
  1047. /*FI*/}
  1048.  else{r256opcode_string2double(C,a1);
  1049. }}
  1050. }
  1051. /*FI*/}
  1052.  else 
  1053. if((49==z1)){
  1054. /*IF*/if (((((T7*)((T7*)a1)))->_count/*4*/)==(1)) {
  1055. r256opcode(C,15,2);
  1056. }
  1057. else {
  1058. {int z2=/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(2)-(1)]/*)*/;
  1059.  
  1060. if((46==z2)){
  1061. /*IF*/if (((((T7*)((T7*)a1)))->_count/*4*/)==(2)) {
  1062. r256opcode(C,15,2);
  1063. }
  1064.  else if ((((((T7*)((T7*)a1)))->_count/*4*/)==(3))&&((/*(IRF4.6item*/((((T7*)((T7*)a1)))->_storage/*0*/)[(3)-(1)]/*)*/)==('0'))) {
  1065. r256opcode(C,15,2);
  1066. }
  1067. else {
  1068. r256opcode_string2double(C,a1);
  1069. }
  1070. /*FI*/}
  1071.  else{r256opcode_string2double(C,a1);
  1072. }}
  1073. }
  1074. /*FI*/}
  1075.  else{r256opcode_string2double(C,a1);
  1076. }}
  1077. }
  1078. /*No:CODE_ATTRIBUTE.fz_38*/
  1079. void r256opcode_dstore(T256* C,int a1){
  1080. /*IF*/if ((a1)<=(3)) {
  1081. r256opcode(C,(71)+(a1),-(1));
  1082. }
  1083. else {
  1084. r256opcode(C,57,-(1));
  1085. /*[IRF3.6add_u1*/{int b1=a1;
  1086. r226add_last(((T226*)(oBC256code)),b1);
  1087. }/*]*/
  1088. }
  1089. /*FI*/}
  1090. /*No:CODE_ATTRIBUTE.fz_57*/
  1091. void r256opcode_string2double(T256* C,T0* a1){
  1092. int _idx=0;
  1093. _idx=r95idx_string(((T95*)(oBC364constant_pool)),a1);
  1094. r256opcode_ldc(C,_idx);
  1095. _idx=r95idx_methodref3(((T95*)(oBC364constant_pool)),((T0*)ms188_470),((T0*)ms186_470),((T0*)ms187_470));
  1096. r256opcode_invokestatic(C,_idx,0);
  1097. }
  1098. /*No:CODE_ATTRIBUTE.fz_39*/
  1099. /*No:CODE_ATTRIBUTE.opcode_iaload*/
  1100. /*No:CODE_ATTRIBUTE.opcode_i2d*/
  1101. /*No:CODE_ATTRIBUTE.fz_jvm_root*/
  1102. int r256opcode_ifnonnull(T256* C){
  1103. int R=0;
  1104. r256opcode(C,199,-(1));
  1105. R=r256skip_2_bytes();
  1106. return R;
  1107. }
  1108. /*No:CODE_ATTRIBUTE.fz_58*/
  1109. /*No:CODE_ATTRIBUTE.opcode_arraylength*/
  1110. /*No:CODE_ATTRIBUTE.fz_49*/
  1111. /*No:CODE_ATTRIBUTE.opcode_aload_3*/
  1112. /*No:CODE_ATTRIBUTE.opcode_iload_3*/
  1113. /*No:CODE_ATTRIBUTE.current_stack_level*/
  1114. /*No:CODE_ATTRIBUTE.opcode_pop*/
  1115. /*No:CODE_ATTRIBUTE.fz_exit*/
  1116. void r256resolve_u2_branch(int a1){
  1117. int _offset=0;
  1118. _offset=((/*(IRF4.9program_counter*//*(IRF4.6count*/((((T226*)((T226*)(oBC256code))))->_upper/*8*/)+(1)/*)*//*)*/)-(a1))+(1);
  1119. /*[IRF3.5put*/((((T226*)((T226*)(oBC256code))))->_storage/*0*/)[a1]=((_offset)/(256));
  1120. /*]*/
  1121. /*[IRF3.5put*/((((T226*)((T226*)(oBC256code))))->_storage/*0*/)[(a1)+(1)]=((_offset)%(256));
  1122. /*]*/
  1123. }
  1124. void r256opcode_fstore(T256* C,int a1){
  1125. /*IF*/if ((a1)<=(3)) {
  1126. r256opcode(C,(67)+(a1),-(1));
  1127. }
  1128. else {
  1129. r256opcode(C,56,-(1));
  1130. /*[IRF3.6add_u1*/{int b1=a1;
  1131. r226add_last(((T226*)(oBC256code)),b1);
  1132. }/*]*/
  1133. }
  1134. /*FI*/}
  1135. /*No:CODE_ATTRIBUTE.opcode_d2i*/
  1136. void r256opcode(T256* C,int a1,int a2){
  1137. /*[IRF3.6add_u1*/{int b1=a1;
  1138. r226add_last(((T226*)(oBC256code)),b1);
  1139. }/*]*/
  1140. C->_current_stack_level=((((T256*)C))->_current_stack_level/*4*/)+(a2);
  1141. /*IF*/if (((((T256*)C))->_current_stack_level/*4*/)>((((T256*)C))->_max_stack/*0*/)) {
  1142. C->_max_stack=(((T256*)C))->_current_stack_level/*4*/;
  1143. }
  1144. /*FI*/}
  1145. /*No:CODE_ATTRIBUTE.opcode_imul*/
  1146. void r256opcode_system_out(T256* C){
  1147. int _idx=0;
  1148. _idx=r95idx_fieldref3(((T95*)(oBC364constant_pool)),((T0*)ms168_470),((T0*)ms171_470),((T0*)ms172_470));
  1149. r256opcode_getstatic(C,_idx,1);
  1150. }
  1151. int r256extra_local(T256* C,T0* a1){
  1152. int R=0;
  1153. R=(((T256*)C))->_max_locals/*8*/;
  1154. C->_max_locals=((((T256*)C))->_max_locals/*8*/)+(X291jvm_stack_space(a1));
  1155. return R;
  1156. }
  1157. int r256opcode_ifge(T256* C){
  1158. int R=0;
  1159. r256opcode(C,156,-(1));
  1160. R=r256skip_2_bytes();
  1161. return R;
  1162. }
  1163. void r256opcode_putstatic(T256* C,int a1,int a2){
  1164. r256opcode(C,179,a2);
  1165. r256add_u2(a1);
  1166. }
  1167. void r256opcode_getstatic(T256* C,int a1,int a2){
  1168. r256opcode(C,178,a2);
  1169. r256add_u2(a1);
  1170. }
  1171. /*No:CODE_ATTRIBUTE.opcode_i2f*/
  1172. int r256opcode_if_icmple(T256* C){
  1173. int R=0;
  1174. r256opcode(C,164,-(2));
  1175. R=r256skip_2_bytes();
  1176. return R;
  1177. }
  1178. /*No:CODE_ATTRIBUTE.opcode_return*/
  1179. void r256opcode_string2float(T256* C,T0* a1){
  1180. r256opcode_string2double(C,a1);
  1181. /*[IRF3.4opcode_d2f*/r256opcode(C,144,-(1));
  1182. /*]*/
  1183. }
  1184. /*No:CODE_ATTRIBUTE.opcode_swap*/
  1185. int r256opcode_if_acmpeq(T256* C){
  1186. int R=0;
  1187. r256opcode(C,165,-(2));
  1188. R=r256skip_2_bytes();
  1189. return R;
  1190. }
  1191. /*No:CODE_ATTRIBUTE.opcode_ddiv*/
  1192. void r256opcode_system_in(T256* C){
  1193. int _idx=0;
  1194. _idx=r95idx_fieldref3(((T95*)(oBC364constant_pool)),((T0*)ms168_470),((T0*)ms169_470),((T0*)ms170_470));
  1195. r256opcode_getstatic(C,_idx,1);
  1196. }
  1197. /*No:CODE_ATTRIBUTE.opcode_dup_x1*/
  1198. int r256extra_local_size1(T256* C){
  1199. int R=0;
  1200. R=(((T256*)C))->_max_locals/*8*/;
  1201. C->_max_locals=((((T256*)C))->_max_locals/*8*/)+(1);
  1202. return R;
  1203. }
  1204. void r256opcode_goto_backward(T256* C,int a1){
  1205. int _offset=0;
  1206. int _q=0;
  1207. int _r=0;
  1208. _offset=(/*(IRF4.9program_counter*//*(IRF4.6count*/((((T226*)((T226*)(oBC256code))))->_upper/*8*/)+(1)/*)*//*)*/)-(a1);
  1209. r256opcode(C,167,0);
  1210. _r=(_offset)%(256);
  1211. _q=(_offset)/(256);
  1212. /*IF*/if ((_r)==(0)) {
  1213. /*[IRF3.6add_u1*/{int b1=(256)-(_q);
  1214. r226add_last(((T226*)(oBC256code)),b1);
  1215. }/*]*/
  1216. /*[IRF3.6add_u1*/{int b1=0;
  1217. r226add_last(((T226*)(oBC256code)),b1);
  1218. }/*]*/
  1219. }
  1220. else {
  1221. /*[IRF3.6add_u1*/{int b1=(255)-(_q);
  1222. r226add_last(((T226*)(oBC256code)),b1);
  1223. }/*]*/
  1224. /*[IRF3.6add_u1*/{int b1=(256)-(_r);
  1225. r226add_last(((T226*)(oBC256code)),b1);
  1226. }/*]*/
  1227. }
  1228. /*FI*/}
  1229. void r256opcode_ldc(T256* C,int a1){
  1230. /*IF*/if ((a1)<(255)) {
  1231. r256opcode(C,18,1);
  1232. /*[IRF3.6add_u1*/{int b1=a1;
  1233. r226add_last(((T226*)(oBC256code)),b1);
  1234. }/*]*/
  1235. }
  1236. else {
  1237. r256opcode(C,19,1);
  1238. r256add_u2(a1);
  1239. }
  1240. /*FI*/}
  1241. /*No:CODE_ATTRIBUTE.opcode_iand*/
  1242. void r256opcode_push_integer(T256* C,int a1){
  1243. /*IF*/if ((a1)<(-(32768))) {
  1244. r256push_strange_integer(C,a1);
  1245. }
  1246.  else if ((a1)<(-(128))) {
  1247. r256opcode_sipush(C,a1);
  1248. }
  1249.  else if ((a1)<=(-(1))) {
  1250. r256opcode_bipush(C,a1);
  1251. }
  1252.  else if ((a1)<=(5)) {
  1253. /*[IRF3.6opcode_iconst_i*/{T256* C1=C;
  1254. int b1=a1;
  1255. r256opcode(C1,(3)+(b1),1);
  1256. }/*]*/
  1257. }
  1258.  else if ((a1)<=(127)) {
  1259. r256opcode_bipush(C,a1);
  1260. }
  1261.  else if ((a1)<=(32767)) {
  1262. r256opcode_sipush(C,a1);
  1263. }
  1264. else {
  1265. r256push_strange_integer(C,a1);
  1266. }
  1267. /*FI*/}
  1268. void r256check_closing(T256* C){
  1269. /*[IRF3.4opcode_iconst_0*/r256opcode(C,3,1);
  1270. /*]*/
  1271. r256opcode_putstatic(C,(((T256*)C))->_check_flag_idx/*16*/,-(1));
  1272. r256resolve_u2_branch((((T256*)C))->_skip_check/*12*/);
  1273. }
  1274. void r256opcode_istore(T256* C,int a1){
  1275. /*IF*/if ((a1)<=(3)) {
  1276. r256opcode(C,(59)+(a1),-(1));
  1277. }
  1278. else {
  1279. r256opcode(C,54,-(1));
  1280. /*[IRF3.6add_u1*/{int b1=a1;
  1281. r226add_last(((T226*)(oBC256code)),b1);
  1282. }/*]*/
  1283. }
  1284. /*FI*/}
  1285. /*No:CODE_ATTRIBUTE.opcode_dadd*/
  1286. /*No:TYPE_GENERIC.fz_is_invalid*/
  1287. int r720id(T720* C){
  1288. int R=0;
  1289. R=(((T355*)((T355*)(r720run_class(C)))))->_id/*4*/;
  1290. return R;
  1291. }
  1292. void r720jvm_target_descriptor_in(T720* C,T0* a1){
  1293. /*IF*/if (r720is_dummy_expanded(C)) {
  1294. r7extend(((T7*)a1),'B');
  1295. }
  1296. /*FI*/}
  1297. /*No:TYPE_GENERIC.jvm_if_x_eq*/
  1298. int r720has_creation(T720* C,T0* a1){
  1299. int R=0;
  1300. R=r605has_creation(((T605*)(r720base_class(C))),a1);
  1301. return R;
  1302. }
  1303. /*No:TYPE_GENERIC.set_run_type_memory*/
  1304. /*No:TYPE_GENERIC.is_anchored*/
  1305. /*No:TYPE_GENERIC.is_array*/
  1306. int r720is_a(T720* C,T0* a1){
  1307. int R=0;
  1308. T0* _t2=NULL;
  1309. T0* _t1=NULL;
  1310. int _i=0;
  1311. /*IF*/if (X291is_none(a1)) {
  1312. }
  1313.  else if ((r720run_class(C))==((void*)(X291run_class(a1)))) {
  1314. R=1;
  1315. }
  1316.  else if (X291is_generic(a1)) {
  1317. /*IF*/if ((r720base_class(C))==((void*)(X291base_class(a1)))) {
  1318. R=1;
  1319. _i=(((T701*)((T701*)((((T720*)C))->_generic_list/*8*/))))->_upper/*8*/;
  1320. while (!((!(R))||((_i)==(0)))) {
  1321. _t1=X291run_type(r701item(((T701*)((((T720*)C))->_generic_list/*8*/)),_i));
  1322. _t2=X291run_type(r701item(((T701*)(X291generic_list(a1))),_i));
  1323. /*IF*/if (X291is_a(_t1,_t2)) {
  1324. _i=(_i)-(1);
  1325. }
  1326. else {
  1327. R=0;
  1328. /*[IRF3.6append*/{T0* b1=((T0*)ms59_470);
  1329. r7append(((T7*)(oBC683explanation)),b1);
  1330. }/*]*/
  1331. }
  1332. /*FI*/}
  1333. }
  1334.  else if (r605is_subclass_of(((T605*)(r720base_class(C))),X291base_class(a1))) {
  1335. R=r605is_a_vncg(((T605*)(r720base_class(C))),(T0*)C,a1);
  1336. }
  1337. /*FI*/}
  1338. else {
  1339. /*IF*/if (r605is_subclass_of(((T605*)(r720base_class(C))),X291base_class(a1))) {
  1340. R=1;
  1341. }
  1342. /*FI*/}
  1343. /*FI*//*IF*/if (!(R)) {
  1344. r683add_type((T0*)C,((T0*)ms71_470));
  1345. r683add_type(a1,((T0*)ms1_720));
  1346. }
  1347. /*FI*/return R;
  1348. }
  1349. /*No:TYPE_GENERIC.jvm_to_reference*/
  1350. T0* r720run_type(T720* C){
  1351. T0* R=NULL;
  1352. /*IF*/if (r720is_run_type(C)) {
  1353. R=(((T720*)C))->_run_type_memory/*16*/;
  1354. }
  1355. /*FI*/return R;
  1356. }
  1357. /*No:TYPE_GENERIC.is_pointer*/
  1358. int r720is_dummy_expanded(T720* C){
  1359. int R=0;
  1360. /*IF*/if (r720is_user_expanded(C)) {
  1361. R=(r355writable_attributes(((T355*)(r720run_class(C)))))==((void*)(NULL));
  1362. }
  1363. /*FI*/return R;
  1364. }
  1365. int r720jvm_push_default(T720* C){
  1366. int R=0;
  1367. R=1;
  1368. /*IF*/if (r720is_expanded(C)) {
  1369. r355jvm_expanded_push_default(((T355*)(r720run_class(C))));
  1370. }
  1371. else {
  1372. /*[IRF3.4opcode_aconst_null*/r256opcode(((T256*)(oBC364code_attribute)),1,1);
  1373. /*]*/
  1374. }
  1375. /*FI*/return R;
  1376. }
  1377. /*No:TYPE_GENERIC.is_string*/
  1378. /*No:TYPE_GENERIC.is_like_feature*/
  1379. /*No:TYPE_GENERIC.is_like_current*/
  1380. void r720basic_checks(T720* C){
  1381. T0* _fgl=NULL;
  1382. T0* _bc=NULL;
  1383. _bc=r720base_class(C);
  1384. _fgl=(((T605*)((T605*)_bc)))->_formal_generic_list/*28*/;
  1385. /*IF*/if ((_fgl)==((void*)(NULL))) {
  1386. r683add_position(/*(IRF4.6start_position*/(((T451*)((T451*)((((T720*)C))->_base_class_name/*4*/))))->_start_position/*4*//*)*/);
  1387. /*[IRF3.6append*/{T0* b1=(((T451*)((T451*)((((T605*)((T605*)_bc)))->_base_class_name/*24*/))))->_to_string/*0*/;
  1388. r7append(((T7*)(oBC683explanation)),b1);
  1389. }/*]*/
  1390. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms2_720);
  1391. r683fatal_error(((T683*)(oBC364eh)),b1);
  1392. }/*]*/
  1393. }
  1394.  else if ((/*(IRF4.6count*/(((T681*)((T681*)((((T881*)((T881*)_fgl)))->_list/*4*/))))->_upper/*8*//*)*/)!=(r701count(((T701*)((((T720*)C))->_generic_list/*8*/))))) {
  1395. r683add_position(/*(IRF4.6start_position*/(((T451*)((T451*)((((T720*)C))->_base_class_name/*4*/))))->_start_position/*4*//*)*/);
  1396. r683add_position((((T881*)((T881*)_fgl)))->_start_position/*0*/);
  1397. /*[IRF3.6fatal_error*/{T0* b1=((T0*)ms61_470);
  1398. r683fatal_error(((T683*)(oBC364eh)),b1);
  1399. }/*]*/
  1400. }
  1401. /*FI*/}
  1402. void r720make(T720* C,T0* a1,T0* a2){
  1403. T0* _t=NULL;
  1404. int _i=0;
  1405. C->_base_class_name=a1;
  1406. C->_generic_list=a2;
  1407. r7copy(((T7*)(oBC720tmp_mark)),(((T451*)((T451*)a1)))->_to_string/*0*/);
  1408. r7extend(((T7*)(oBC720tmp_mark)),'\133');
  1409. _i=1;
  1410. while (!((_i)>((((T701*)((T701*)a2)))->_upper/*8*/))) {
  1411. _t=r701item(((T701*)a2),_i);
  1412. r7append(((T7*)(oBC720tmp_mark)),X291written_mark(_t));
  1413. _i=(_i)+(1);
  1414. /*IF*/if ((_i)<=((((T701*)((T701*)a2)))->_upper/*8*/)) {
  1415. r7extend(((T7*)(oBC720tmp_mark)),'\54');
  1416. }
  1417. /*FI*/}
  1418. r7extend(((T7*)(oBC720tmp_mark)),'\135');
  1419. C->_written_mark=r902item(oBC720tmp_mark);
  1420. }
  1421. T0* r720jvm_root_class(void){
  1422. if (fBC364jvm_root_class==0){
  1423. T0* R=NULL;
  1424. fBC364jvm_root_class=1;
  1425. {T7*n=malloc(sizeof(*n));
  1426. *n=M7;
  1427. r7make(n,12);
  1428. R=(T0*)n;
  1429. }
  1430. r7copy(((T7*)R),(((T228*)((T228*)(oBC364jvm))))->_output_name/*16*/);
  1431. r7extend(((T7*)R),'\57');
  1432. r7append(((T7*)R),((T0*)ms112_470));
  1433. oBC364jvm_root_class=R;}
  1434. return oBC364jvm_root_class;}
  1435. T0* r720type_any(void){
  1436. if (fBC364type_any==0){
  1437. T0* R=NULL;
  1438. fBC364type_any=1;
  1439. {T669*n=malloc(sizeof(*n));
  1440. *n=M669;
  1441. r669make(n,NULL);
  1442. R=(T0*)n;
  1443. }
  1444. oBC364type_any=R;}
  1445. return oBC364type_any;}
  1446. void r720jvm_return_code(T720* C){
  1447. /*IF*/if (r720is_expanded(C)) {
  1448. r355jvm_expanded_return_code(((T355*)(r720run_class(C))));
  1449. }
  1450. else {
  1451. /*[IRF3.2opcode_areturn*//*[IRF3.6add_u1*/{int b1=176;
  1452. r226add_last(((T226*)(oBC256code)),b1);
  1453. }/*]*/
  1454. /*]*/
  1455. }
  1456. /*FI*/}
  1457. /*No:TYPE_GENERIC.jvm_xnewarray*/
  1458. void r720jvm_descriptor_in(T720* C,T0* a1){
  1459. /*IF*/if (r720is_expanded(C)) {
  1460. r355jvm_expanded_descriptor_in(((T355*)(r720run_class(C))),a1);
  1461. }
  1462. else {
  1463. r7append(((T7*)a1),r720jvm_root_descriptor());
  1464. }
  1465. /*FI*/}
  1466. /*No:TYPE_GENERIC.start_position*/
  1467. /*No:TYPE_GENERIC.fz_inako*/
  1468. int r720is_user_expanded(T720* C){
  1469. int R=0;
  1470. R=(((T605*)((T605*)(r720base_class(C)))))->_is_expanded/*20*/;
  1471. return R;
  1472. }
  1473. /*No:TYPE_GENERIC.is_character*/
  1474. /*No:TYPE_GENERIC.written_mark*/
  1475. T0* r720to_runnable(T720* C,T0* a1){
  1476. T0* R=NULL;
  1477. T0* _rt=NULL;
  1478. T0* _t2=NULL;
  1479. T0* _t1=NULL;
  1480. T0* _rgl=NULL;
  1481. int _i=0;
  1482. /*IF*/if (((((T720*)C))->_run_type_memory/*16*/)==((void*)(NULL))) {
  1483. /*IF*/if (r720is_written_runnable(C)) {
  1484. C->_run_type_memory=(T0*)C;
  1485. r720basic_checks(C);
  1486. R=(T0*)C;
  1487. }
  1488. else {
  1489. _rgl=r701twin(((T701*)((((T720*)C))->_generic_list/*8*/)));
  1490. _i=(((T701*)((T701*)_rgl)))->_upper/*8*/;
  1491. while (!((_i)==(0))) {
  1492. _t1=r701item(((T701*)_rgl),_i);
  1493. _t2=X291to_runnable(_t1,a1);
  1494. /*IF*/if (((_t2)==((void*)(NULL)))||(!(X291is_run_type(_t2)))) {
  1495. r683add_type(_t1,((T0*)ms72_470));
  1496. r683print_as_error(((T683*)(oBC364eh)));
  1497. _i=0;
  1498. }
  1499. else {
  1500. /*[IRF3.6put*/{T701* C1=((T701*)_rgl);
  1501. T0* b1=_t2;
  1502. int b2=_i;
  1503. ((((T701*)C1))->_storage/*0*/)[(b2)-((((T701*)C1))->_lower/*12*/)]=(b1);
  1504. }/*]*/
  1505. }
  1506. /*FI*/_t2=X291run_type(_t2);
  1507. /*IF*/if (X291is_expanded(_t2)) {
  1508. r355set_at_run_time(((T355*)(X291run_class(_t2))));
  1509. }
  1510. /*FI*/_i=(_i)-(1);
  1511. }
  1512. {T720*n=malloc(sizeof(*n));
  1513. *n=M720;
  1514. r720make_runnable(n,(T0*)C,_rgl);
  1515. _rt=(T0*)n;
  1516. }
  1517. /*IF*/if (((((T720*)C))->_run_type_memory/*16*/)==((void*)(NULL))) {
  1518. C->_run_type_memory=_rt;
  1519. R=(T0*)C;
  1520. }
  1521. else {
  1522. R=r720twin(C);
  1523. /*[IRF3.3set_run_type_memory*/((((T720*)(((T720*)R))))->_run_type_memory)=(_rt);
  1524. /*]*/
  1525. }
  1526. /*FI*/}
  1527. /*FI*/}
  1528.  else if (r720is_written_runnable(C)) {
  1529. R=(T0*)C;
  1530. }
  1531. else {
  1532. _rgl=r701twin(((T701*)((((T720*)C))->_generic_list/*8*/)));
  1533. _i=(((T701*)((T701*)_rgl)))->_upper/*8*/;
  1534. while (!((_i)==(0))) {
  1535. _t1=r701item(((T701*)_rgl),_i);
  1536. _t2=X291to_runnable(_t1,a1);
  1537. /*IF*/if (((_t2)==((void*)(NULL)))||(!(X291is_run_type(_t2)))) {
  1538. r683add_type(_t1,((T0*)ms72_470));
  1539. r683print_as_error(((T683*)(oBC364eh)));
  1540. _i=0;
  1541. }
  1542. else {
  1543. /*[IRF3.6put*/{T701* C1=((T701*)_rgl);
  1544. T0* b1=_t2;
  1545. int b2=_i;
  1546. ((((T701*)C1))->_storage/*0*/)[(b2)-((((T701*)C1))->_lower/*12*/)]=(b1);
  1547. }/*]*/
  1548. }
  1549. /*FI*/_t2=X291run_type(_t2);
  1550. /*IF*/if (X291is_expanded(_t2)) {
  1551. r355set_at_run_time(((T355*)(X291run_class(_t2))));
  1552. }
  1553. /*FI*/_i=(_i)-(1);
  1554. }
  1555. {T720*n=malloc(sizeof(*n));
  1556. *n=M720;
  1557. r720make_runnable(n,(T0*)C,_rgl);
  1558. _rt=(T0*)n;
  1559. }
  1560. R=r720twin(C);
  1561. /*[IRF3.3set_run_type_memory*/((((T720*)(((T720*)R))))->_run_type_memory)=(_rt);
  1562. /*]*/
  1563. }
  1564. /*FI*/return R;
  1565. }
  1566. int r720is_run_type(T720* C){
  1567. int R=0;
  1568. /*IF*/if (((((T720*)C))->_run_type_memory/*16*/)!=((void*)(NULL))) {
  1569. R=1;
  1570. }
  1571.  else if (r720is_written_runnable(C)) {
  1572. C->_run_type_memory=(T0*)C;
  1573. r720basic_checks(C);
  1574. R=1;
  1575. }
  1576. /*FI*/return R;
  1577. }
  1578. /*No:TYPE_GENERIC.run_type_memory*/
  1579. /*No:TYPE_GENERIC.is_formal_generic*/
  1580. /*No:TYPE_GENERIC.generic_list*/
  1581. /*No:TYPE_GENERIC.is_real*/
  1582. int r720is_written_runnable(T720* C){
  1583. int R=0;
  1584. T0* _t=NULL;
  1585. int _i=0;
  1586. R=1;
  1587. _i=(((T701*)((T701*)((((T720*)C))->_generic_list/*8*/))))->_upper/*8*/;
  1588. while (!((!(R))||((_i)==(0)))) {
  1589. _t=r701item(((T701*)((((T720*)C))->_generic_list/*8*/)),_i);
  1590. /*IF*/if (X291is_run_type(_t)) {
  1591. /*IF*/if ((X291run_type(_t))==((void*)(_t))) {
  1592. }
  1593. else {
  1594. R=0;
  1595. }
  1596. /*FI*/}
  1597. else {
  1598. R=0;
  1599. }
  1600. /*FI*/_i=(_i)-(1);
  1601. }
  1602. return R;
  1603. }
  1604. T0* r720twin(T720* C){
  1605. T0* R=NULL;
  1606. R=malloc(sizeof(*C));
  1607. *((T720*)R)=*C;
  1608. return R;
  1609. }
  1610. /*No:TYPE_GENERIC.fz_bnga*/
  1611. void r720standard_jvm_check_class_invariant(T720* C){
  1612. /*IF*/if (r590invariant_check(((T590*)(oBC364run_control)))) {
  1613. r355jvm_check_class_invariant(((T355*)(r720run_class(C))));
  1614. }
  1615. /*FI*/}
  1616. /*No:TYPE_GENERIC.is_bit*/
  1617. /*No:TYPE_GENERIC.jvm_check_class_invariant*/
  1618. T0* r720jvm_root_descriptor(void){
  1619. if (fBC364jvm_root_descriptor==0){
  1620. T0* R=NULL;
  1621. fBC364jvm_root_descriptor=1;
  1622. {T7*n=malloc(sizeof(*n));
  1623. *n=M7;
  1624. r7make(n,12);
  1625. R=(T0*)n;
  1626. }
  1627. r7extend(((T7*)R),'L');
  1628. r7append(((T7*)R),r720jvm_root_class());
  1629. r7extend(((T7*)R),'\73');
  1630. oBC364jvm_root_descriptor=R;}
  1631. return oBC364jvm_root_descriptor;}
  1632. /*No:TYPE_GENERIC.jvm_xaload*/
  1633. T0* r720smallest_ancestor(T720* C,T0* a1){
  1634. T0* R=NULL;
  1635. T0* _rto=NULL;
  1636. _rto=X291run_type(a1);
  1637. /*IF*/if (X291is_none(a1)) {
  1638. R=(T0*)C;
  1639. }
  1640.  else if (X291is_any(_rto)) {
  1641. R=_rto;
  1642. }
  1643.  else if (X291is_a(_rto,r720run_type(C))) {
  1644. R=(((T720*)C))->_run_type_memory/*16*/;
  1645. }
  1646. else {
  1647. /*[IRF3.2cancel*//*[IRF3.3clear*/((((T7*)(((T7*)(oBC683explanation)))))->_count)=(0);
  1648. /*]*/
  1649. r38clear(((T38*)(oBC683positions)));
  1650. /*]*/
  1651. /*IF*/if (r720is_a(((T720*)(r720run_type(C))),_rto)) {
  1652. R=_rto;
  1653. }
  1654. else {
  1655. /*[IRF3.2cancel*//*[IRF3.3clear*/((((T7*)(((T7*)(oBC683explanation)))))->_count)=(0);
  1656. /*]*/
  1657. r38clear(((T38*)(oBC683positions)));
  1658. /*]*/
  1659. /*IF*/if (X291is_generic(_rto)) {
  1660. R=r720type_any();
  1661. }
  1662. else {
  1663. R=X291smallest_ancestor(_rto,(T0*)C);
  1664. }
  1665. /*FI*/}
  1666. /*FI*/}
  1667. /*FI*/return R;
  1668. }
  1669. /*No:TYPE_GENERIC.is_boolean*/
  1670. T0*oBC720tmp_mark=NULL;
  1671. /*No:TYPE_GENERIC.is_double*/
  1672. int r720jvm_stack_space(void){
  1673. int R=0;
  1674. /*IF*//*AF*//*AE*/
  1675. R=1;
  1676. /*FI*/return R;
  1677. }
  1678. T0* r720run_class(T720* C){
  1679. T0* R=NULL;
  1680. /*IF*/if (r720is_run_type(C)) {
  1681. R=r604run_class((((T720*)C))->_run_type_memory/*16*/);
  1682. }
  1683. /*FI*/return R;
  1684. }
  1685. T0* r720run_time_mark(T720* C){
  1686. T0* R=NULL;
  1687. /*IF*/if (r720is_run_type(C)) {
  1688. R=(((T720*)((T720*)((((T720*)C))->_run_type_memory/*16*/))))->_written_mark/*12*/;
  1689. }
  1690. /*FI*/return R;
  1691. }
  1692. int r720is_a_in(T720* C,T0* a1,T0* a2){
  1693. int R=0;
  1694. T0* _ct=NULL;
  1695. T0* _t2=NULL;
  1696. T0* _t1=NULL;
  1697. /*IF*/if (((((T720*)C))->_written_mark/*12*/)==((void*)(X291written_mark(a1)))) {
  1698. R=1;
  1699. }
  1700. else {
  1701. _ct=(((T355*)((T355*)a2)))->_current_type/*0*/;
  1702. _t1=r720to_runnable(C,_ct);
  1703. _t2=X291to_runnable(a1,_ct);
  1704. /*IF*/if ((X291run_time_mark(_t1))==((void*)(X291run_time_mark(_t2)))) {
  1705. R=1;
  1706. }
  1707. else {
  1708. R=X291is_a(_t1,_t2);
  1709. }
  1710. /*FI*/}
  1711. /*FI*/return R;
  1712. }
  1713. T0* r720look_up_for(T720* C,T0* a1,T0* a2){
  1714. T0* R=NULL;
  1715. R=r605look_up_for(((T605*)(r720base_class(C))),a1,a2);
  1716. return R;
  1717. }
  1718. /*No:TYPE_GENERIC.jvm_convert_to*/
  1719. T0* r720expanded_initializer(T720* C){
  1720. T0* R=NULL;
  1721. /*IF*/if (r720is_expanded(C)) {
  1722. R=r605expanded_initializer(((T605*)(r720base_class(C))),(T0*)C);
  1723. }
  1724. /*FI*/return R;
  1725. }
  1726. /*No:TYPE_GENERIC.fz_jvm_root*/
  1727. /*No:TYPE_GENERIC.jvm_if_x_ne*/
  1728. /*No:TYPE_GENERIC.fz_dot*/
  1729. /*No:TYPE_GENERIC.is_generic*/
  1730. /*No:TYPE_GENERIC.fz_bga*/
  1731. void r720jvm_write_local(T720* C,int a1){
  1732. /*IF*/if (r720is_expanded(C)) {
  1733. r355jvm_expanded_write_local(((T355*)(r720run_class(C))),a1);
  1734. }
  1735. else {
  1736. r256opcode_astore(((T256*)(oBC364code_attribute)),a1);
  1737. }
  1738. /*FI*/}
  1739. void r720jvm_initialize_local(T720* C,int a1){
  1740. /*IF*/if (r720is_expanded(C)) {
  1741. r355jvm_expanded_push_default(((T355*)(r720run_class(C))));
  1742. }
  1743. else {
  1744. /*[IRF3.4opcode_aconst_null*/r256opcode(((T256*)(oBC364code_attribute)),1,1);
  1745. /*]*/
  1746. }
  1747. /*FI*/r720jvm_write_local(C,a1);
  1748. }
  1749. /*No:TYPE_GENERIC.used_as_reference*/
  1750. int r720is_reference(T720* C){
  1751. int R=0;
  1752. R=!((((T605*)((T605*)(r720base_class(C)))))->_is_expanded/*20*/);
  1753. return R;
  1754. }
  1755. T0* r720base_class(T720* C){
  1756. T0* R=NULL;
  1757. T0* _bcn=NULL;
  1758. _bcn=(((T720*)C))->_base_class_name/*4*/;
  1759. /*IF*/if ((_bcn)!=((void*)(NULL))) {
  1760. R=r451base_class(((T451*)_bcn));
  1761. }
  1762. else {
  1763. /*[IRF3.6append*/{T0* b1=((T0*)ms3_291);
  1764. r7append(((T7*)(oBC683explanation)),b1);
  1765. }/*]*/
  1766. r683add_type((T0*)C,((T0*)ms67_470));
  1767. r683print_as_fatal_error(((T683*)(oBC364eh)));
  1768. }
  1769. /*FI*/return R;
  1770. }
  1771. /*No:TYPE_GENERIC.jvm_xastore*/
  1772. /*No:TYPE_GENERIC.fatal_error*/
  1773. /*No:TYPE_GENERIC.is_any*/
  1774.  
  1775.